// 汉字学习API服务
const BASE_URL = 'http://localhost:8000/api';

export const hanziApi = {
  // API基础URL
  baseUrl: BASE_URL,

  // 定义难度级别常量
  LEVELS: {
    BEGINNER: 'beginner',
    INTERMEDIATE: 'intermediate',
    ADVANCED: 'advanced'
  },

  // 修改请求方法，添加token和401处理
  async request(options) {
    try {
      const token = uni.getStorageSync('token');
      const response = await uni.request({
        ...options,
        header: {
          'Authorization': token ? `Bearer ${token}` : '',
          ...options.header
        }
      });

      // 处理401状态码
      if (response.statusCode === 401) {
        // 清除本地存储的token
        uni.removeStorageSync('token');
        uni.removeStorageSync('userInfo');
        
        // 跳转到登录页
        uni.reLaunch({
          url: '/pages/auth/login'
        });
        throw new Error('需要登录');
      }

      return response;
    } catch (error) {
      throw error;
    }
  },

  // 上传用户签名图片进行评分
  async uploadSignatureForScoring(userImagePath, characterCode, strokeIndex) {
    return new Promise((resolve, reject) => {
      console.log('开始上传签名图片进行评分');
      console.log('图片路径:', userImagePath);
      console.log('字符编码:', characterCode);
      console.log('笔画索引:', strokeIndex);
      
      // 显示加载中
      uni.showLoading({
        title: '评分中...'
      });
      
      try {
        // 获取token，如果有的话
        const token = uni.getStorageSync('token');
        
        // 构建请求URL
        const requestUrl = `${this.baseUrl}/hanzi-score/score`;
        console.log('请求URL:', requestUrl);
        
        // 从characterCode获取原始汉字
        const standardChar = String.fromCharCode(parseInt(characterCode));
        console.log('标准汉字:', standardChar);
        
        // 上传文件
        uni.uploadFile({
          url: requestUrl,
          filePath: userImagePath,
          name: 'userImage',
          formData: {
            standardImage: standardChar, // 变更为标准汉字字符串
            strokeIndex: strokeIndex
          },
          header: {
            'Authorization': token ? `Bearer ${token}` : '',
            'Content-Type': 'multipart/form-data'
          },
          success: (res) => {
            uni.hideLoading();
            
            console.log('上传响应:', res);
            
            if (res.statusCode === 200) {
              try {
                const result = typeof res.data === 'string' ? JSON.parse(res.data) : res.data;
                console.log('解析结果:', result);
                resolve(result);
              } catch (err) {
                console.error('响应解析失败:', err);
                console.error('原始响应:', res.data);
                
                // 尝试开发模式评分
                this.getDevelopmentScore(strokeIndex)
                  .then(result => resolve(result))
                  .catch(err => reject(err));
              }
            } else if (res.statusCode === 403) {
              console.error('无权限访问API (403)');
              this.getDevelopmentScore(strokeIndex)
                .then(result => resolve(result))
                .catch(err => reject(err));
            } else {
              console.error(`API请求失败，状态码: ${res.statusCode}`);
              this.getDevelopmentScore(strokeIndex)
                .then(result => resolve(result))
                .catch(err => reject(err));
            }
          },
          fail: (err) => {
            uni.hideLoading();
            console.error('上传请求失败:', err);
            
            // 如果上传失败，也尝试使用开发模式分数
            this.getDevelopmentScore(strokeIndex)
              .then(result => resolve(result))
              .catch(err => reject(err));
          }
        });
      } catch (err) {
        uni.hideLoading();
        console.error('上传过程中发生错误:', err);
        
        // 任何异常情况下都使用开发模式分数
        this.getDevelopmentScore(strokeIndex)
          .then(result => resolve(result))
          .catch(err => reject(err));
      }
    });
  },
  
  // 开发模式下生成本地评分数据
  async getDevelopmentScore(strokeIndex) {
    return new Promise((resolve) => {
      console.log('使用开发模式评分数据');
      
      // 使用延迟模拟网络请求
      setTimeout(() => {
        // 生成随机但合理的分数
        const baseScore = 75 + Math.floor(Math.random() * 21); // 75-95的基础分
        
        // 生成评分数据
        const scoreData = {
          totalScore: baseScore,
          shapeScore: baseScore - 5 + Math.floor(Math.random() * 10),
          strokeQualityScore: baseScore - 7 + Math.floor(Math.random() * 14),
          structureScore: baseScore - 3 + Math.floor(Math.random() * 6),
          aestheticScore: baseScore - 10 + Math.floor(Math.random() * 20),
          feedback: "开发模式评分: 这是本地生成的评分数据，仅用于开发测试。在实际应用中，这里将显示基于AI分析的详细反馈信息。"
        };
        
        // 确保分数在合理范围内
        Object.keys(scoreData).forEach(key => {
          if (key !== 'feedback' && typeof scoreData[key] === 'number') {
            scoreData[key] = Math.min(100, Math.max(0, scoreData[key]));
          }
        });
        
        console.log('生成的评分数据:', scoreData);
        resolve(scoreData);
      }, 800); // 添加延迟以模拟网络请求
    });
  },

  // 获取用户当前学习阶段的汉字
  getUserCharacters() {
    return this.request({
      url: `${BASE_URL}/user/characters`,
      method: 'GET'
    });
  },

  // 获取单个汉字详情
  getCharacter(char) {
    return this.request({
      url: `${BASE_URL}/characters/${char}`,
      method: 'GET'
    });
  },

  // 获取汉字列表
  getCharacters(page = 1, size = 20, level = '') {
    return this.request({
      url: `${BASE_URL}/characters`,
      method: 'GET',
      data: { page, size, level }
    });
  },
  
  // 获取分类列表
  getCategories() {
    return this.request({
      url: `${BASE_URL}/categories`,
      method: 'GET'
    });
  },
  
  // 获取分类汉字
  getCategoryCharacters(categoryId, page = 1, limit = 20) {
    return this.request({
      url: `${BASE_URL}/category/${categoryId}/characters`,
      method: 'GET',
      data: { page, limit }
    });
  },
  
  // 获取每日推荐汉字
  getDailyCharacter() {
    return this.request({
      url: `${BASE_URL}/characters/daily`,
      method: 'GET'
    });
  },
  
  // 获取用户学习进度
  getUserProgress() {
    return this.request({
      url: `${BASE_URL}/user/progress`,
      method: 'GET'
    });
  },
  
  // 更新学习进度
  updateProgress(character, status) {
    return this.request({
      url: `${BASE_URL}/progress`,
      method: 'POST',
      data: { character, status }
    });
  },
  
  // 获取游戏数据
  getGameData(gameType, level = 1) {
    return this.request({
      url: `${BASE_URL}/games/${gameType}`,
      method: 'GET',
      data: { level }
    });
  },

  // 获取汉字笔画数据
  getCharacterStrokes(hanzi) {
    return this.request({
      url: `${BASE_URL}/strokes/data/${hanzi}`,
      method: 'GET'
    });
  },

  // 获取汉字笔顺SVG
  getCharacterStrokeSvg(hanzi) {
    return this.request({
      url: `${BASE_URL}/strokes/svg/${hanzi}`,
      method: 'GET',
      responseType: 'text'
    });
  },
  
  // 获取汉字笔顺动画HTML
  getCharacterAnimation(hanzi) {
    return this.request({
      url: `${BASE_URL}/strokes/animation/${hanzi}`,
      method: 'GET',
      responseType: 'text'
    });
  },
  
  // 获取汉字笔顺GIF图
  getCharacterStrokeGif(hanzi) {
    return this.request({
      url: `${BASE_URL}/strokes/gif/${hanzi}`,
      method: 'GET',
      responseType: 'image'
    });
  },
  
  // 获取汉字笔顺GIF图URL(通过字符查询API)
  async getCharacterStrokeGifUrl(hanzi) {
    try {
      // 获取汉字详情数据
      const response = await this.request({
        // url: `${BASE_URL}/strokes/image/${hanzi}`,
		url: `${BASE_URL}/strokes/gif/${hanzi}`,
        method: 'GET'
      });
      console.log(response);
      return response;
    } catch (error) {
      console.error('获取汉字笔顺GIF失败:', error);
      throw error;
    }
  },
  
  // 获取汉字特定笔画的图片(base64编码)
  getCharacterStrokeImage(character, strokeIndex) {
    return this.request({
      url: `${BASE_URL}/strokes/image/${character}/${strokeIndex}`,
      method: 'GET',
      responseType: 'text' // 返回base64编码
    });
  },
}; 